SD45. 부호 정수를 무부호 정수로 타입 변환 오류 — 안전한 에러값으로 치환

원본 항목: Part 5. 코드 오류 — 3. 부호 정수를 무부호 정수로 타입 변환 오류 CWE-195 repo 폴더: sd45_signconv/ (빌드·실행은 §3-1) 목표 시간: 1회차 10분 / 2회차 6분 / 3회차 4분 -1이 unsigned int로 감기면 4294967295가 된다는 걸 값 비교로 확인하는 데서 그치지 않고, 그 값이 실제 경계 검사를 무력화시키는 순간까지 재현한다.

이 드릴의 문서 구성 (SD01~SD58 공통)

① 요구사항서 — 어떤 코드가 뚫려 있고, 무엇을 만드나. ② pseudo code 템플릿 — Bad 와 Good 의 뼈대이고, 회차마다 가린다. ③ 테스트 코드 — 공격은 막히고 정상은 통과해야 끝이다. ④ 자주 하는 실수 ⑤ 모범답안 — 맨 뒤에 접어 둔다.

변형 A/B/C 는 같은 치환 규칙을 다른 소재로 다시 치는 것이다.

---

0. 이 드릴로 체화할 것

  unsigned int len(char *s) {
-     if (s == NULL) return -1;      /* -1 -> 4294967295 */
+     if (s == NULL) return 0;       /* 무부호에 안전한 0 반환 */
      return strnlen(s, BUFSIZE-1);
  }

에러를 -1로 표시하는 관용구는 반환형이 signed일 때만 안전하다. 반환형이 unsigned인 함수에서 -1은 최댓값으로 감겨버려, “에러”가 “역대 가장 큰 정상값”으로 둔갑한다.

회차별 진행

회차	변형	보는 것	순서
1회차	A 문자열 길이 조회 + 경계 검사	① 요구사항서 ② pseudo code 전체	1. Bad 를 그대로 쳐서 취약점을 관찰한다. 2. Good pseudo 를 한 줄씩 코드로 바꾼다. 3. ③ 테스트를 실행한다.
2회차	B memcpy 길이 인자로 변형	① 요구사항서 ② pseudo code 의 번호와 제목만 (Level 2)	1. Bad 를 치고 취약점을 확인한다. 2. 번호만 보고 Good 을 쓴다. 3. ③ 테스트를 실행한다.
3회차	C size_t 버전으로 확장	① 요구사항서만	1. ③ 테스트를 먼저 읽는다. 2. 백지에서 Bad 부터 Good 까지 재현한다.

1회차에 막히면 같은 변형을 한 번 더 친다. 3회차를 통과하면 A 를 백지로 다시 친다.

---

1. 요구사항서

1-A. 변형 A — 문자열 길이 조회 + 경계 검사

문자열의 길이를 구해 인덱스 접근 범위를 검사하는 데 사용한다.

• 문자열이 NULL이면 그 어떤 인덱스도 “범위 안”으로 판정되어서는 안 된다.

함수

unsigned int len_bad(const char *s);
unsigned int len_good(const char *s);
int within_len_bad(unsigned int idx, const char *s);
int within_len_good(unsigned int idx, const char *s);

신뢰 경계

값	출처	검증 없이 흘러가는 곳
len_bad()의 반환값(unsigned int)	NULL 에러 표시(-1)	이후 idx < len 같은 경계 검사식의 우변

공격 입력표

입력	Bad 결과	이유
len_bad(NULL)	4294967295(UINT_MAX)	-1이 unsigned int로 변환되며 최댓값으로 감긴다
within_len_bad(999999, NULL)	참(범위 안으로 착각)	999999 < 4294967295이 참이 되어, 원래는 무조건 거부돼야 할 접근이 통과해버린다
같은 상황(Good)	within_len_good(999999, NULL) → 거짓	len_good(NULL)이 0이라 999999 < 0은 항상 거짓(무부호라 음수 자체가 없음에도 검사가 의도대로 작동)

1-B. 변형 B — memcpy 길이 인자로 변형

len_bad의 결과를 memcpy(dst, src, len)의 세 번째 인자로 그대로 넘기는 함수를 만들어, “거대한 길이로 복사를 시도하다 즉시 실패/크래시”하는 것까지 이어서 본다(직접 memcpy를 실행하지 않고 “그 크기를 받아들이는지”만 확인해도 충분하다)

1-C. 변형 C — size_t 버전으로 확장

unsigned int 대신 size_t(64비트 플랫폼에서는 8바이트)로 바꿔, 같은 문제가 자료형이 커져도 동일하게 발생함을 확인한다

---

2. pseudo code 템플릿 — 보고 쳐서 익힌다

사용법 변형별로 아래 pseudo code 를 소스 파일에 주석만 복사한다. 코드는 주석을 보고 내가 쓴다. 다 쓰면 [ ] 를 x 로 바꾼다. 막히면 §5 모범답안(A)의 해당 단계만 본다.

2-A. len_good — Level 1 (1회차, 전부 본다)

먼저 Bad 를 그대로 쳐서 §3 의 test_bad_is_vulnerable 이 통과하는지(= 실제로 뚫리는지) 확인한다. 그다음 Good 을 쓴다.

unsigned int len_bad(const char *s)
{
    /* 1. s == NULL 이면 return (unsigned int)-1   ← 4294967295 (역대 가장 큰 "정상값")
     * 2. return strnlen(s, BUFSIZE - 1) */
}
 
int within_len_bad(unsigned int idx, const char *s)
{
    /* 1. return idx < len_bad(s) */
}
 
unsigned int len_good(const char *s)
{
    /* [ ] 1. s == NULL 이면 → return 0   (무부호에 안전한 에러값) */
 
    /* [ ] 2. return (unsigned int)strnlen(s, BUFSIZE - 1)
     *        BUFSIZE 256 */
}
 
int within_len_good(unsigned int idx, const char *s)
{
    /* [ ] 3. return idx < len_good(s)   ← Bad 와 **같은 식**, 바뀐 건 len 의 에러값 */
}

2-B. len_good — Level 2 (2회차, 번호와 제목만 본다)

unsigned int len_good(const char *s)
{
    /* [ ] 1. s == NULL 이면 → return 0   (무부호에 안전한 에러값) */
 
    /* [ ] 2. return (unsigned int)strnlen(s, BUFSIZE - 1) */
}
 
int within_len_good(unsigned int idx, const char *s)
{
    /* [ ] 3. return idx < len_good(s)   ← Bad 와 **같은 식**, 바뀐 건 len 의 에러값 */
}

2-C. len_good — Level 3 (3회차, 백지)

unsigned int len_good(const char *s)
{
    /* 아무것도 안 본다.
     * §1 요구사항서와 §0 의 치환 규칙만 보고 친다.
     *
     * 막히면 아래만 찾아본다.
     *   - `strnlen` 의 feature macro (`_DEFAULT_SOURCE`)
     *   - 에러값 설계는 반환형이 unsigned 일 때 `0`
     */
}

막혔을 때 찾는 순서

1. 컴파일 에러가 나면 에러 문구를 본다. unknown type name / implicit declaration 이면 include 누락이다.
2. man 3 <함수> 를 연다. SYNOPSIS 맨 위의 #include 를 확인한다.
3. 로직이 막히면 §3 테스트의 기대값을 먼저 읽는다. 공격 입력표(§1)와 테스트가 답이다.
4. 그래도 안 되면 모범답안의 해당 단계 하나만 본다.

---

3. 테스트 코드 — 이게 통과하면 끝

sd45_signconv/src/signconv.h
sd45_signconv/src/signconv.c
sd45_signconv/test/test.c

시험 구조는 고정이다 (SD01~SD58 공통)

1. Bad 가 실제로 뚫린다. 이 시험이 실패하면 Bad 를 잘못 옮겨 적은 것이다.
2. Bad 도 정상 입력은 처리한다.
3. Good 이 같은 공격을 막는다.
4. Good 이 정상 입력까지 막지 않는다. (과잉 차단 없음)

3-A. 변형 A 시험 — 이 형태를 고정한다

#include <stdio.h>
#include <limits.h>
#include "signconv.h"
 
static int g_fail = 0;
#define T_TRUE(cond, msg) \
    do { if (!(cond)) { g_fail++; \
        printf("  X %s:%d %s\n", __func__, __LINE__, msg); } } while (0)
 
static void test_bad_wraps_to_uint_max(void)
{
    T_TRUE(len_bad(NULL) == UINT_MAX,
        "Bad는 NULL에서 -1을 unsigned로 반환해 UINT_MAX로 감겨야 한다(취약점 재현)");
}
 
static void test_bad_normal(void)
{
    T_TRUE(len_bad("hi") == 2, "정상 문자열은 길이를 정확히 반환해야 한다");
}
 
static void test_good_returns_zero(void)
{
    T_TRUE(len_good(NULL) == 0, "Good은 NULL에서 무부호에 안전한 0을 반환해야 한다");
}
 
static void test_good_normal(void)
{
    T_TRUE(len_good("hi") == 2, "정상 문자열은 길이를 정확히 반환해야 한다");
}
 
static void test_bad_bounds_check_bypassed(void)
{
    T_TRUE(within_len_bad(999999u, NULL) != 0,
        "Bad는 -1이 UINT_MAX로 감겨서 어떤 큰 idx도 범위 안으로 착각해야 한다(경계검사 무력화 재현)");
}
 
static void test_good_bounds_check_holds(void)
{
    T_TRUE(within_len_good(999999u, NULL) == 0,
        "Good은 0을 반환하므로 같은 idx가 범위 밖으로 올바르게 거부돼야 한다");
}
 
int main(void)
{
    test_bad_wraps_to_uint_max();
    test_bad_normal();
    test_good_returns_zero();
    test_good_normal();
    test_bad_bounds_check_bypassed();
    test_good_bounds_check_holds();
    printf(g_fail ? "FAIL %d\n" : "PASS\n", g_fail);
    return g_fail ? 1 : 0;
}

_DEFAULT_SOURCE가 필요하다

strnlen()은 POSIX 확장 함수라 -std=c11 -pedantic 아래에서는 #define _DEFAULT_SOURCE를 첫 #include보다 먼저 적어야 한다(SD06에서 다룬 것과 같은 이슈).

3-B · 3-C. 변형 B / C 시험

3-A 와 같은 4종 구조에서 호출 함수와 입력만 바꾼다.

변형 B — memcpy 길이 인자로 변형

입력	Bad	Good
len_bad(NULL) 를 memcpy 길이로 사용	4GB 복사 시도	길이 0 → 복사 없음
정상 문자열	정상	정상

변형 C — size_t 버전으로 확장

입력	Bad	Good
size_t 반환형에 (size_t)-1	64비트 최댓값	0
정상 문자열	정상	정상

3-1. 빌드와 실행 (Makefile, gcc)

Makefile 은 템플릿 체화 드릴 README 와 같은 파일이다. recipe 줄은 반드시 탭으로 들여쓴다.

공통 Makefile (gcc)

# ~/cdrill/Makefile  (템플릿 체화 드릴과 같은 파일)
# 사용법:  make D=sd01_sqli V=main SRC="common/mock_db.c sd01_sqli/src/sql_auth.c sd01_sqli/test/test.c"
CC       := gcc
CFLAGS   := -Wall -Wextra -Werror -std=c11 -D_POSIX_C_SOURCE=200809L -g -DUNIT_TEST -Icommon -I$(D)/src
SAN      := -fsanitize=address,undefined -fno-omit-frame-pointer
LDLIBS   ?= -pthread
 
D        ?= d1_pure
V        ?= main
SRC      ?= $(D)/src/$(V).c $(D)/test/test_$(V).c
BIN      := build/$(D)_$(V)
 
all: run
 
build:
	@mkdir -p build
 
$(BIN): build $(SRC)
	$(CC) $(CFLAGS) $(SAN) $(SRC) $(LDLIBS) -o $(BIN)
 
run: $(BIN)
	@echo "── run ──────────────────────────────"
	@./$(BIN)
 
check: $(BIN)
	@./$(BIN) && echo "PASS" || (echo "FAIL"; exit 1)
 
clean:
	rm -rf build
 
.PHONY: all run check clean build

실행 명령이다.

make D=sd45_signconv V=main SRC="sd45_signconv/src/signconv.c sd45_signconv/test/test.c"

• 마지막 줄이 PASS 이고 경고 0 이면 통과다.
• -Werror 때문에 컴파일이 안 되면 테스트 이전에 코드를 고친다.

참고: Makefile 없이 순수 gcc 로 실행

mkdir -p build
gcc -Wall -Wextra -Werror -std=c11 -D_POSIX_C_SOURCE=200809L -g -DUNIT_TEST \
    -Icommon -Isd45_signconv/src \
    -fsanitize=address,undefined -fno-omit-frame-pointer \
    sd45_signconv/src/signconv.c sd45_signconv/test/test.c \
    -pthread -o build/sd45_signconv_main
./build/sd45_signconv_main

---

4. 자주 하는 실수

실수	왜 문제인가
return -1을 return (unsigned int)0 - 1로 바꿔서 “고쳤다”고 착각	표현만 바뀌었을 뿐 값은 여전히 UINT_MAX다. 핵심은 “감기지 않는 표현”이 아니라 **“에러를 나타내는 값 자체를 0처럼 안전한 값으로 바꾸는 것”**이다
호출자 쪽에서 (int)len_bad(s) == -1로 검사하려 함	함수가 이미 unsigned int를 반환하기로 계약했는데 호출자가 다시 int로 캐스팅해 검사하는 건 임시방편이다. 함수 시그니처 자체(반환형과 에러값)를 무부호에 안전하게 설계하는 게 근본 해결책이다
”이 값이 인덱스나 길이로 쓰이지 않으니 상관없다”고 넘김	지금 안 쓰여도 나중에 다른 코드가 이 반환값을 경계 검사나 메모리 크기로 재사용할 수 있다. 함수의 반환값 계약은 사용처와 무관하게 항상 안전해야 한다

---

5. 모범답안 (변형 A)

다 치고 나서 열 것 — signconv.h / signconv.c

#ifndef SIGNCONV_H
#define SIGNCONV_H
unsigned int len_bad(const char *s);
unsigned int len_good(const char *s);
int within_len_bad(unsigned int idx, const char *s);
int within_len_good(unsigned int idx, const char *s);
#endif

#define _DEFAULT_SOURCE
#include <string.h>
#include "signconv.h"
 
#define BUFSIZE 256
 
unsigned int len_bad(const char *s)
{
    if (s == NULL) return (unsigned int)-1;   /* -1 -> 4294967295 */
    return (unsigned int)strnlen(s, BUFSIZE - 1);
}
 
unsigned int len_good(const char *s)
{
    if (s == NULL) return 0;                   /* 무부호에 안전한 0 반환 */
    return (unsigned int)strnlen(s, BUFSIZE - 1);
}
 
int within_len_bad(unsigned int idx, const char *s)
{
    return idx < len_bad(s);
}
 
int within_len_good(unsigned int idx, const char *s)
{
    return idx < len_good(s);
}

눈여겨볼 점: within_len_bad와 within_len_good은 완전히 동일한 코드(idx < len(s))다. 버그는 이 비교식이 아니라 비교 대상이 되는 함수의 에러값 설계에 있었다. 같은 로직이라도 그 로직이 딛고 선 함수의 계약이 잘못되면 결과가 뒤집힌다는 걸 보여주는 좋은 예다.

---

관련 노트

• 시큐어코딩 체화 드릴 목록
• 이전: SD44. 부적절한 자원 해제
• 다음: SD46. 정수를 문자로 변환